1
2
3
4
Következő
Keresse meg az indexOf használatával az eltávolítani kívánt tömbelem indexét, majd távolítsa el ezt az indexet toldással.
A splice () metódus eltávolítással megváltoztatja egy tömb tartalmát
meglévő elemek és / vagy új elemek hozzáadása.
const tömb = [2, 5, 9];
console.log (tömb);
const index = tömb.indexOf (5);
if (index> -1) {
tömb.splice (index, 1);
}
// tömb = [2, 9]
console.log (tömb);
A toldás második paramétere az eltávolítandó elemek száma. Vegye figyelembe, hogy a toldás módosítja a tömböt a helyén, és egy új tömböt ad vissza, amely tartalmazza az eltávolított elemeket.
A teljesség kedvéért itt vannak funkciók. Az első függvény csak egyetlen előfordulást távolít el (azaz eltávolítja az első 5-ös egyezést a [2,5,9,1,5,8,5] -ből), míg a második függvény minden előfordulást eltávolít:
function removeItemOnce (arr, érték) {
var index = arr.indexOf (érték);
if (index> -1) {
arr.splice (index, 1);
}
visszatérő arr;
}
function removeItemAll (arr, érték) {
var i = 0;
míg (i = 0; i--) {
if (tömb [i] === szám) {
tömb.splice (i, 1);
}
}
Ha azt szeretné, hogy az i indexben lévő elem már ne létezzen, de nem szeretné, hogy a többi elem indexe megváltozzon:
tömb törlése [i];
|
Szerkesztve: 2016. október
Tegye egyszerű, intuitív és egyértelmű (Occam borotva)
Változtathatatlan (az eredeti tömb változatlan marad)
Ha a böngészője nem támogatja ezeket, használja a szokásos JavaScript funkciókat - használja a polyfill alkalmazást
Ebben a kód példában az "array.filter (...)" funkciót használom a nem kívánt elemek eltávolításához egy tömbből. Ez a funkció nem változtatja meg az eredeti tömböt, és újat hoz létre. Ha böngészője nem támogatja ezt a funkciót (pl. Internet Explorer 9 előtt, vagy Firefox 1.5 előtt), fontolja meg a Mozilla szűrő polifill használatát.
Elem eltávolítása (ECMA-262 5. kiadás kód, más néven oldstyle JavaScript)
var érték = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (függvény (elem) {
return item! == érték
})
console.log (arr)
// [1, 2, 4, 5]
Elem eltávolítása (ECMAScript 6 kód)
legyen érték = 3
legyen arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (elem => elem! == érték)
console.log (arr)
// [1, 2, 4, 5]
FONTOS ECMAScript 6 "() => {}" nyíl funkció szintaxist egyáltalán nem támogatja az Internet Explorer, a Chrome 45-ös verzió előtt, a Firefox 22-es verzió előtt és a Safari 10-es verzió előtt. Az ECMAScript 6 szintaxisának régi böngészőkben történő használatához használhatja a BabelJS alkalmazást.
Több elem eltávolítása (ECMAScript 7 kód)
A módszer további előnye, hogy több elemet eltávolíthat
let forDeletion = [2, 3, 5]
legyen arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Olvassa el alább az array-ról. (...) támogatást tartalmaz !!!
console.log (arr)
// [1, 4]
FONTOS Az "array.includes (...)" funkciót egyáltalán nem támogatja az Internet Explorer, a Chrome 47-es verzió előtt, a Firefox 43-as verzió előtt, a Safari 9-es verzió előtt és az Edge 14-es verzió előtt, tehát itt van a Mozilla polyfill-je.
Több elem eltávolítása (esetleg a jövőben)
Ha valaha is elfogadják a "Ez a kötelező szintaxis" javaslatot, akkor ezt megteheti:
// array-lib.js
export függvény eltávolítás (... forDeletion) {
adja vissza ezt: szűrő (item =>! forDeletion.includes (item))
}
// main.js
importálás {eltávolítás} a ./array-lib.js fájlból
legyen arr = [1, 2, 3, 4, 5, 3]
// :: Ez a kötelező érvényű szintaxis javaslat
// az "remove" függvény használata "virtuális módszerként"
// az Array.prototype kiterjesztése nélkül
arr = arr :: eltávolít (2, 3, 5)
console.log (arr)
// [1, 4]
Próbáld ki te is a BabelJS-ben :)
Referencia
A tömb.prototípus. magában foglalja
Funkcionális összetétel
|
Attól függ, hogy üres helyet akar-e tartani, vagy sem.
Ha üres helyet akarsz:
tömb [index] = undefined;
Ha nem akar üres rést:
// Az eredeti megőrzése:
// oldArray = [... tömb];
// Ez módosítja a tömböt.
tömb.splice (index, 1);
És ha szüksége van az elem értékére, akkor egyszerűen elmentheti a visszaküldött tömb elemét:
var érték = tömb.splice (index, 1) [0];
Ha a tömb mindkét végén el akarja távolítani, használhatja az array.pop () -t az utolsóhoz, vagy az array.shift () -t az elsőhöz (mindkettő visszaadja az elem értékét is).
Ha nem ismeri az elem indexét, használhatja az array.indexOf (item) fájlt (egy if (egy elem megszerzéséhez, vagy egy idő után () az összes megszerzéséhez). Az array.indexOf (item) az indexet vagy a -1 értéket adja vissza, ha nem található.
|
Egy barátomnak problémái voltak az Internet Explorer 8-ban, és megmutatta, mit tett. Mondtam neki, hogy helytelen, ő pedig azt mondta, hogy megkapta a választitt. A jelenlegi legfelsőbb válasz nem működik minden böngészőben (például az Internet Explorer 8 alkalmazásban), és csak az elem első előfordulását távolítja el.
Távolítsa el az ÖSSZES példányt egy tömbből
function array_remove_index_by_value (arr, elem)
{
for (var i = arr.length; i--;)
{
if (arr [i] === elem) {arr.splice (i, 1);}
}
}
Visszafelé halad a tömbön (mivel az indexek és a hossz megváltozik az elemek eltávolításával), és eltávolítja az elemet, ha megtalálta. Minden böngészőben működik.
|
Két fő megközelítés létezik:
toldás (): anArray.splice (index, 1);
törlés: anArray [index] törlése;
Legyen körültekintő, ha a törlést tömbhöz használja. Jó objektumok attribútumainak törléséhez, de tömbökhöz nem annyira jó. A tömbökhöz jobb a kötést használni.
Ne feledje, hogy egy tömb törlése esetén rossz eredményeket kaphat az anArray.length kifejezésre. Más szavakkal, a törlés eltávolítja az elemet, de nem frissíti a length tulajdonság értékét.
Arra is számíthat, hogy a törlés használata után lyukak lesznek az indexszámokban, pl. végül az 1, 3, 4, 8, 9 és 11 indexek és hosszúságúak lehetnek, mint a törlés előtt volt. Ebben az esetben az összes hurokhoz indexelt összeomlik, mivel az indexek már nem egymást követik.
Ha valamilyen okból kénytelen a törlést használni, akkor az egyes hurkokhoz használja, amikor tömbökön keresztül kell hurcolnia. Tulajdonképpen mindig kerülje az indexelt ciklusok használatát, ha lehetséges. Így a kód robusztusabb és kevésbé hajlamos az indexekkel kapcsolatos problémákra.
|
Array.prototype.remove_by_value = function (val) {
mert (var i = 0; i sor.id === 5);
var eltávolítva = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Meghatározás
var segítő = {
// Távolítsa el és adja vissza az első előfordulást
removeOne: függvény (tömb, állítmány) {
for (var i = 0; i [2, 3, 4]
|
Használhatja az ES6-ot. Például a „3” érték törléséhez ebben az esetben:
var tömb = ['1', '2', '3', '4', '5', '6']
var newArray = tömb.szűrő ((érték) => érték! = '3');
console.log (newArray);
Kimenet :
["1", "2", "4", "5", "6"]
|
Ha új tömböt szeretne eltávolítani a törölt pozíciókról, akkor mindig törölheti az adott elemet és kiszűrheti a tömböt. Lehet, hogy szüksége lesz a tömbobjektum kiterjesztésére azoknál a böngészőknél, amelyek nem valósítják meg a szűrési módszert, de hosszú távon könnyebb, mivel csak ezt teszi:
var my_array = [1, 2, 3, 4, 5, 6];
törölje a my_array [4];
console.log (my_array.filter (függvény (a) {return typeof a! == 'undefined';}));
Megjelenik az [1, 2, 3, 4, 6].
|
Íme néhány módszer egy elem eltávolítására egy tömbből a JavaScript használatával.
Az összes ismertetett módszer nem mutálja az eredeti tömböt, hanem létrehoz egy újat.
Ha ismeri az elem indexét
Tegyük fel, hogy van tömbje, és el akar távolítani egy elemet az i pozícióból.
Az egyik módszer a slice () használata:
const tételek = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
config
console.log (filteredItems)
A slice () új tömböt hoz létre a kapott indexekkel. Egyszerűen létrehozunk egy új tömböt a kezdetektől az eltávolítani kívánt indexig, és összefűzünk egy másik tömböt az első pozíciótól az eltávolított sor után a tömb végéig.
Ha tudja az értéket
Ebben az esetben az egyik jó lehetőség a filter () használata, amely deklaratívabb megközelítést kínál:
const elemek = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Ez az ES6 nyílfüggvényeket használja. A hagyományos funkciókkal támogathatja a régebbi böngészőket:
const tételek = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter (function (item) {
return item! == valueToRemove
})
console.log (filteredItems)
vagy használhatja a Babelt, és az ES6 kódot visszamásolja az ES5-be, hogy jobban emészthetővé tegye a régi böngészők számára, mégis modern JavaScriptet írjon a kódba.
Több elem eltávolítása
Mi van, ha egyetlen elem helyett sok elemet szeretne eltávolítani?
Keressük meg a legegyszerűbb megoldást.
Index szerint
Csak létrehozhat egy függvényt és eltávolíthat elemeket sorozatból:
const tételek = ['a', 'b', 'c', 'd', 'e', 'f']
const removeItem = (elemek, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
hadd filteredItems = removeItem (elemek, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Érték szerint
A visszahívási funkcióban kereshet felvételt:
const tételek = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Kerülje az eredeti tömb mutációját
a splice () (nem tévesztendő össze a slice-el ()) mutálja az eredeti tömböt, és kerülni kell.
(eredetileg a webhelyemen tették közzé: https://flaviocopes.com/how-to-remove-item-from-array/)
|
Nézze meg ezt a kódot. Minden nagyobb böngészőben működik.
remove_item = function (arr, érték) {
var b = '';
for (b in arr) {
if (arr [b] === érték) {
arr.plice (b, 1);
szünet;
}
}
visszatérő arr;
};
Hívja ezt a funkciót
remove_item (tömb, érték);
|
ES6 és mutáció nélkül: (2016. október)
const removeByIndex = (lista, index) =>
[
... list.slice (0, index),
... list.slice (index + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (output)
|
Használhatja a lodash _.pull (mutate tömb), _.pullAt (mutate tömb) vagy _. nélkül (nem mutál tömböt)
var array1 = ['a', 'b', 'c', 'd']
_.pull (tömb1, 'c')
console.log (tömb1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (2. tömb, 0)
console.log (tömb2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (tömb3, 'i') // ['j', 'k', 'l']
console.log (tömb3) // ['i', 'j', 'k', 'l']
|
Egy adott elem / karakterlánc eltávolítása egy tömbből egyvonalas módon történhet:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
ahol:
theArray: az a tömb, amelyből valami konkrétat el akarsz távolítani
stringToRemoveFromArray: az eltávolítani kívánt karakterlánc és 1 az eltávolítani kívánt elemek mennyisége.
JEGYZET: Ha a "stringToRemoveFromArray" nem található a tömbben, ez eltávolítja a tömb utolsó elemét.
Mindig jó gyakorlat annak eltávolítása előtt ellenőrizni, hogy az elem létezik-e a tömbben.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Ha az ügyfél számítógépén hozzáfér az újabb Ecmascript verziókhoz (FIGYELEM, lehet, hogy régebbi állomásokon nem működik):
var tömb = ['1', '2', '3', '4', '5', '6']
var newArray = tömb.szűrő ((érték) => érték! = '3');
Ahol '3' az az érték, amelyet el akarsz távolítani a tömbből.
A tömb ekkor változik: ['1', '2', '4', '5', '6']
|
OK, például van az alábbi tömb:
var szám = [1, 2, 3, 4, 5];
És törölni akarjuk a 4. számot. Egyszerűen használhatja az alábbi kódot:
num.splice (num.indexOf (4), 1); // szám [1, 2, 3, 5] lesz;
Ha újra használja ezt a funkciót, akkor írjon egy újrafelhasználható függvényt, amely az alábbiak szerint csatolódik a natív tömbfüggvényhez:
Array.prototype.remove = Array.prototype.remove || függvény (x) {
const i = ez.indexOf (x);
ha (i === - 1)
Visszatérés;
ez. (i, 1) szelet; // szám.eltávolítás (5) === [1, 2, 3];
}
De mi lenne, ha megvan az alábbi tömb, néhány [5] másodperccel a tömbben?
var szám = [5, 6, 5, 4, 5, 1, 5];
Szükségünk van egy hurokra az összes ellenőrzéséhez, de egy egyszerűbb és hatékonyabb módszer a beépített JavaScript-függvények használata, ezért írunk egy olyan függvényt, amely az alábbiakhoz hasonló szűrőt használ:
const _removeValue = (arr, x) => arr.szűrő (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Vannak harmadik féltől származó könyvtárak is, amelyek segítenek ebben, például a Lodash vagy az Aláhúzás. További információ: lodash _.pull, _.pullAt vagy _. nélkül.
|
Teljesítmény
Ma (2019-12-09) teljesítményteszteket végzek a macOS v10.13.6 (High Sierra) verzión a kiválasztott megoldásokhoz. Megmutatom a delete (A) -t, de más módszerekhez képest nem használom, mert üres helyet hagyott a tömbben.
A következtetések
a leggyorsabb megoldás a array.splice (C) (kivéve a Safari kis tömbökhöz, ahol másodszor van)
nagy tömbök esetén az array.slice + splice (H) a leggyorsabban megváltoztathatatlan megoldás a Firefox és a Safari számára; Az Array.from (B) a leggyorsabb a Chrome-ban
a változtatható megoldások általában 1,5x-6x gyorsabbak, mint a megváltoztathatatlanok
a Safari kis asztalainál meglepő módon a mutálható megoldás (C) lassabb, mint a megváltoztathatatlan megoldás (G)
Részletek
A tesztekben különböző módon távolítom el a középső elemet a tömbből. Az A, C megoldások a helyükön vannak. A B, D, E, F, G, H oldatok változhatatlanok.
10 elemű tömb eredményei
A Chrome-ban az array.splice (C) a leggyorsabb helybeni megoldás. Az array.filter (D) a leggyorsabban megváltoztathatatlan megoldás. A leglassabb a tömb.szelet (F). Itt végezheti el a tesztet a gépén.
Eredmények a tömbre 1.000.000 elemmel
A Chrome-ban az array.splice (C) a leggyorsabb helymegoldás (a törlés (C) hasonló gyorsan - de üres rést hagyott a tömbben (tehát nem hajt végre 'teljes eltávolítást'). Az array.slice-splice (H) a leggyorsabban megváltoztathatatlan megoldás. A leglassabb az array.filter (D és E). Itt végezheti el a tesztet a gépén.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (levél, tömb) => konzol.log (levél, tömb.csatlakozás `,`);
A függvény (tömb) {
var index = tömb.indexOf (5);
tömb törlése [index];
log ('A', tömb);
}
B függvény (tömb) {
var index = tömb.indexOf (5);
var arr = tömb.from (tömb);
arr.splice (index, 1)
log ('B', arr);
}
C függvény (tömb) {
var index = tömb.indexOf (5);
tömb.splice (index, 1);
log ('C', tömb);
}
D függvény (tömb) {
var arr = tömb.szűrő (elem => elem! == 5)
napló ('D', arr);
}
E függvény (tömb) {
var index = tömb.indexOf (5);
var arr = tömb.szűrő ((elem, i) => i! == index)
napló ('E', arr);
}
F függvény (tömb) {
var index = tömb.indexOf (5);
var arr = tömb.slice (0, index) .concat (tömb.szelet (index + 1))
napló ('F', arr);
}
függvény G (tömb) {
var index = tömb.indexOf (5);
var arr = [... tömb.szelet (0, index), ... tömb.szelet (index + 1)]
log ('G', arr);
}
H függvény (tömb) {
var index = tömb.indexOf (5);
var arr = tömb.szelet (0);
arr.splice (index, 1);
log ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
Ha]);
Ez a kódrészlet csak a teljesítménytesztekben használt kódot mutatja be - önmagát nem hajtja végre.
Böngészők összehasonlítása: Chrome v78.0.0, Safari v13.0.4 és Firefox v71.0.0
|
Még nagyon új vagyok a JavaScript-ben, és szükségem van erre a funkcióra. Csupán ezt írtam:
function removeFromArray (tömb, elem, index) {
míg ((index = tömb.indexOf (elem))> -1) {
tömb.splice (index, 1);
}
}
Aztán amikor használni akarom:
// Állítson be néhány próbabábut
var dummyObj = {név: "miau"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Távolítsa el a dummy adatokat
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Kimenet - A várakozásoknak megfelelően.
["item1", "item1"]
Lehet, hogy más igényei vannak, mint nekem, így könnyedén módosíthatjahogy megfeleljen nekik. Remélem, ez segít valakinek.
|
Ha összetett objektumok vannak a tömbben, használhat szűrőket?
Olyan helyzetekben, amikor a $ .inArray vagy az array.splice használata nem olyan egyszerű. Különösen, ha az objektumok talán sekélyek a tömbben.
Például. ha van egy objektuma, amelynek Id mezője van, és szeretné eltávolítani az objektumot egy tömbből:
this.array = this.array.filter (function (elem, i) {
return elem.id! == idToRemove;
});
|
Az ECMAScript 6 alapján szeretnék válaszolni. Tegyük fel, hogy van egy olyan tömbje, mint az alábbiak:
legyen arr = [1,2,3,4];
Ha egy speciális indexnél, például a 2-nél szeretne törölni, írja be az alábbi kódot:
arr.plice (2, 1); // => arr lett [1,2,4]
De ha törölni szeretne egy speciális elemet, például a 3-at, és nem ismeri annak indexét, tegye a következőket:
arr = arr.szűrő (e => e! == 3); // => arr lett [1,2,4]
Tipp: Kérjük, használja a nyíl funkciót a visszahívás szűréséhez, hacsak nem kap üres tömböt.
|
Frissítés: Ez a módszer csak akkor ajánlott, ha nem tudja használni az ECMAScript 2015 (korábban ES6 néven ismert) fájlt. Ha tudod használni, akkor az itt található más válaszok sokkal finomabb megvalósításokat kínálnak.
Ez a lényeg itt megoldja a problémát, és törli az argumentum minden előfordulását csupán 1 (vagy megadott érték) helyett.
Array.prototype.destroy = function (obj) {
// A null értéket adja vissza, ha nem találhatók objektumok
var elpusztult = null;
mert (var i = 0; i 3
x.destroy (hamis); // => hamis
x; // => [1, 2, igaz, undefined]
x.destroy (igaz); // => igaz
x.destroy (undefined); // => undefined
x; // => [1, 2]
x.destroy (3); // => null
x; // => [1, 2]
|
ES10 frissítés
Ez a bejegyzés összefoglalja az elemek tömbből való eltávolításának általános megközelítéseit az ECMAScript 2019 (ES10) óta.
1. Általános esetek
1.1. Tömb elem eltávolítása érték alapján .splice () használatával
| Helyben: Igen |
| Eltávolítja az ismétlődéseket: Igen (hurok), Nem (indexOf) |
| Érték / index szerint: Index szerint |
Ha ismeri a tömbből eltávolítani kívánt értéket, használhatja a toldási módszert. Először meg kell határoznia a célelem indexét. Ezután az indexet használja kezdő elemként, és csak egy elemet távolít el.
// 'for' hurokkal
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (legyen i = 0; i [1, 2, 3, 4, 6, 7, 8, 9, 0]
// .indexOf () metódussal
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.plice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. A tömb elem eltávolítása a .filter () módszerrel
| Helyben: Nem |
| Eltávolítja a duplikátumokat: Igen |
| Érték / index szerint: Érték szerint |
Egy adott elem kiszűrhető a tömbből, szűrési funkcióval. Ilyen függvényt hívnak meg a tömb minden elemére.
const értéke = 3
legyen arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (elem => elem! == érték)
console.log (arr)
// [1, 2, 4, 5]
1.3. Array elem eltávolítása az Array.prototype kiterjesztésével
| Helyben: Igen / Nem (a megvalósítástól függ) |
| Eltávolítja az ismétlődéseket: Igen / Nem (a megvalósítástól függ) |
| Érték / index szerint: Index / érték szerint (a megvalósítástól függ) |
A tömb prototípusa további módszerekkel bővíthető. Ilyen módszerek akkor használhatók a létrehozott tömbökön.
Megjegyzés: Az objektumok prototípusainak kiterjesztését a JavaScript standard könyvtárából (például az Array-ből) egyesek antipatternak tekintik.
// Helyben, mindent eltávolít értékmegvalósítással
Array.prototype.remove = function (item) {
mert (legyen i = 0; i = ES10)
| Helyben: Nem |
| Eltávolítja az ismétlődéseket: Igen |
| Érték / index szerint: Érték szerint |
Az ES10 bemutatta az Object.fromEntries fájlt, amely lehetfelhasználható a kívánt tömb létrehozásához bármely tömbszerű objektumból és a folyamat során a nem kívánt elemek szűrésére.
konst objektum = [1,2,3,4];
const értékToRemove = 3;
const arr = Object.values (Object.fromEntries (
Object.entries (objektum)
.filter (([kulcs, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Különleges esetek
2.1 Elem eltávolítása, ha a tömb végén van
2.1.1. A tömb hosszának módosítása
| Helyben: Igen |
| Eltávolítja az ismétlődéseket: Nem |
| Érték / index szerint: N / A |
A JavaScript tömb elemei eltávolíthatók a tömb végéből, ha a length tulajdonságot az aktuális értéknél kisebb értékre állítják. Minden elem, amelynek indexe nagyobb vagy egyenlő az új hosszúsággal, eltávolításra kerül.
const arr = [1, 2, 3, 4, 5, 6];
arr.hossz = 5; // Hossz beállítása az elem eltávolításához
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. .Pop () módszerrel
| Helyben: Igen |
| Eltávolítja az ismétlődéseket: Nem |
| Érték / index szerint: N / A |
A pop módszer eltávolítja a tömb utolsó elemét, visszaadja azt az elemet, és frissíti a length tulajdonságot. A pop módszer módosítja a tömböt, amelyre meghívják. Ez azt jelenti, hogy a törléssel ellentétben az utolsó elem teljesen eltávolításra kerül és a tömb hossza csökken.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // 6-ot ad vissza
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Elem eltávolítása, ha a tömb elején van
| Helyben: Igen |
| Eltávolítja az ismétlődéseket: Nem |
| Érték / index szerint: N / A |
A .shift () metódus ugyanúgy működik, mint a pop metódus, kivéve, hogy eltávolítja a JavaScript tömb első elemét az utolsó helyett. Az elem eltávolításakor a többi elem lefelé tolódik.
const arr = [1, 2, 3, 4];
arr.váltás (); // 1-et ad vissza
console.log (arr); // [2, 3, 4]
2.3. Elem eltávolítása, ha ez az egyetlen elem a tömbben
| Helyben: Igen |
| Eltávolítja a duplikátumokat: N / A |
| Érték / index szerint: N / A |
A leggyorsabb módszer az, ha egy tömb változót üres tömbre állítunk.
legyen arr = [1];
arr = []; // üres tömb
Alternatív megoldásként a 2.1.1-es technika alkalmazható a 0-ra történő beállítással.
|
Soha ne mutálja a tömböt. Mivel ez ellentétes a funkcionális programozási mintával. Új tömböt hozhat létre anélkül, hogy hivatkozna arra a tömbre, amelynek adatait módosítani szeretné az ECMAScript 6 módszer szűrő használatával;
var myArray = [1, 2, 3, 4, 5, 6];
Tegyük fel, hogy el akarja távolítani az 5-öt a tömbből, egyszerűen megteheti ezt:
myArray = myArray.filter (érték => érték! == 5);
Ez új tömböt kap az eltávolítani kívánt érték nélkül. Tehát az eredmény:
[1, 2, 3, 4, 6]; // 5 eltávolítva erről a tömbből
A további megértés érdekében olvassa el az MDN dokumentációt az Array.filter oldalon.
|
Korszerűbb, ECMAScript 2015 (korábban Harmony vagy ES 6 néven ismert) megközelítés. Adott:
konst tételek = [1, 2, 3, 4];
const index = 2;
Akkor:
item.filter ((x, i) => i! == index);
Hozam:
[1, 2, 4]
Használhatja a Babelt és a polifill szolgáltatást annak biztosítására, hogy ezt a böngészők jól támogassák.
|
Ha az elemnek több példánya van, akkor visszafelé haladva meggyőződhet arról, hogy nem csavarja-e el az indexeket.
var myElement = "csokoládé";
var myArray = ['csokoládé', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];
/ * Fontos kód * /
for (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Élő bemutató
|
1 és 9 között van a tömbben, és el akarja távolítani az 5. kódot. Használja az alábbi kódot:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = számArray.filter (m => {
visszatér m! = = 5;
});
console.log ("új tömb, 5 eltávolítva", newNumberArray);
Ha több értéket szeretne. Példa: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = számArray.filter (m => {
visszatérés (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("új tömb, 1,7 és 8 eltávolítva", newNumberArray);
Ha el akarja távolítani egy tömb értékét egy tömbben. Példa: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = számArray.filter (m => {
return! removebleArray. magában foglalja (m);
});
console.log ("új tömb, [3,4,5] eltávolítva", newNumberArray);
Tartalmazza a támogatott böngésző linket.
|
1
2
3
4
Következő
Nagyon aktív kérdés. Nyerjen 10 hírnevet a kérdés megválaszolásához. A jó hírnév követelménye megvédi ezt a kérdést a spamektől és a nem válaszolóktól.
Nem a keresett válasz? Böngésszen a javascript tömbökkel címkézett egyéb kérdésekben, vagy tegye fel saját kérdését.